﻿using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using libtcodWrapper;

namespace HDHack
{
    class LevelGenerator
    {
        int SAMPLE_SCREEN_HEIGHT;
        int SAMPLE_SCREEN_WIDTH;
        int bspDepth = 8;
        int minRoomSize = 8;
        bool randomRoom = true; // a room fills a random part of the node or the maximum available space ?
        bool roomWalls = true; // if true, there is always a wall on north & west side of a room
        char[,] bsp_map;
        public LevelGenerator(int h, int w)
        {
            SAMPLE_SCREEN_HEIGHT = h;
            SAMPLE_SCREEN_WIDTH = w;
            bsp_map = new char[w, h];
        }


        #region "BSP Helpers"

        // draw a vertical line
        void vline(char[,] map, int x, int y1, int y2)
        {
            int y = y1;
            int dy = (y1 > y2 ? -1 : 1);
            map[x, y] = ' ';
            if (y1 == y2) return;
            do
            {
                y += dy;
                map[x, y] = ' ';
            } while (y != y2);
        }

        // draw a vertical line up until we reach an empty space
        void vline_up(char[,] map, int x, int y)
        {
            while (y >= 0 && map[x, y] != ' ')
            {
                map[x, y] = ' ';
                y--;
            }
        }

        // draw a vertical line down until we reach an empty space
        void vline_down(char[,] map, int x, int y)
        {
            while (y < SAMPLE_SCREEN_HEIGHT && map[x, y] != ' ')
            {
                map[x, y] = ' ';
                y++;
            }
        }

        // draw a horizontal line
        void hline(char[,] map, int x1, int y, int x2)
        {
            int x = x1;
            int dx = (x1 > x2 ? -1 : 1);
            map[x, y] = ' ';
            if (x1 == x2) return;
            do
            {
                x += dx;
                map[x, y] = ' ';
            } while (x != x2);
        }

        // draw a horizontal line left until we reach an empty space
        void hline_left(char[,] map, int x, int y)
        {
            while (x >= 0 && map[x, y] != ' ')
            {
                map[x, y] = ' ';
                x--;
            }
        }

        // draw a horizontal line right until we reach an empty space
        void hline_right(char[,] map, int x, int y)
        {
            while (x < SAMPLE_SCREEN_WIDTH && map[x, y] != ' ')
            {
                map[x, y] = ' ';
                x++;
            }
        }

        // the class building the dungeon from the bsp nodes
        bool traverse_node(TCODBSP node)
        {
            TCODRandom rnd = new TCODRandom();

            if (node.IsLeaf())
            {
                // calculate the room size
                int minx = node.x + 1;
                int maxx = node.x + node.w - 1;
                int miny = node.y + 1;
                int maxy = node.y + node.h - 1;
                int x, y;
                if (!roomWalls)
                {
                    if (minx > 1) minx--;
                    if (miny > 1) miny--;
                }
                if (maxx == SAMPLE_SCREEN_WIDTH - 1) maxx--;
                if (maxy == SAMPLE_SCREEN_HEIGHT - 1) maxy--;
                if (randomRoom)
                {
                    minx = rnd.GetRandomInt(minx, maxx - minRoomSize + 1);
                    miny = rnd.GetRandomInt(miny, maxy - minRoomSize + 1);
                    maxx = rnd.GetRandomInt(minx + minRoomSize - 1, maxx);
                    maxy = rnd.GetRandomInt(miny + minRoomSize - 1, maxy);
                }
                // resize the node to fit the room
                //	printf("node %dx%d %dx%d => room %dx%d %dx%d\n",node->x,node->y,node->w,node->h,minx,miny,maxx-minx+1,maxy-miny+1);
                node.x = minx;
                node.y = miny;
                node.w = maxx - minx + 1;
                node.h = maxy - miny + 1;
                // dig the room
                for (x = minx; x <= maxx; x++)
                {
                    for (y = miny; y <= maxy; y++)
                    {
                        bsp_map[x, y] = ' ';
                    }
                }
            }
            else
            {
                //	printf("lvl %d %dx%d %dx%d\n",node->level, node->x,node->y,node->w,node->h);
                // resize the node to fit its sons
                TCODBSP left = node.GetLeft();
                TCODBSP right = node.GetRight();

                node.x = System.Math.Min(left.x, right.x);
                node.y = System.Math.Min(left.y, right.y);
                node.w = System.Math.Max(left.x + left.w, right.x + right.w) - node.x;
                node.h = System.Math.Max(left.y + left.h, right.y + right.h) - node.y;
                // create a corridor between the two lower nodes
                if (node.horizontal)
                {
                    // vertical corridor
                    if (left.x + left.w - 1 < right.x || right.x + right.w - 1 < left.x)
                    {
                        // no overlapping zone. we need a Z shaped corridor
                        int x1 = rnd.GetRandomInt(left.x, left.x + left.w - 1);
                        int x2 = rnd.GetRandomInt(right.x, right.x + right.w - 1);
                        int y = rnd.GetRandomInt(left.y + left.h, right.y);
                        vline_up(bsp_map, x1, y - 1);
                        hline(bsp_map, x1, y, x2);
                        vline_down(bsp_map, x2, y + 1);
                    }
                    else
                    {
                        // straight vertical corridor
                        int minx = System.Math.Max(left.x, right.x);
                        int maxx = System.Math.Min(left.x + left.w - 1, right.x + right.w - 1);
                        int x = rnd.GetRandomInt(minx, maxx);
                        vline_down(bsp_map, x, right.y);
                        vline_up(bsp_map, x, right.y - 1);
                    }
                }
                else
                {
                    // horizontal corridor
                    if (left.y + left.h - 1 < right.y || right.y + right.h - 1 < left.y)
                    {
                        // no overlapping zone. we need a Z shaped corridor
                        int y1 = rnd.GetRandomInt(left.y, left.y + left.h - 1);
                        int y2 = rnd.GetRandomInt(right.y, right.y + right.h - 1);
                        int x = rnd.GetRandomInt(left.x + left.w, right.x);
                        hline_left(bsp_map, x - 1, y1);
                        vline(bsp_map, x, y1, y2);
                        hline_right(bsp_map, x + 1, y2);
                    }
                    else
                    {
                        // straight horizontal corridor
                        int miny = System.Math.Max(left.y, right.y);
                        int maxy = System.Math.Min(left.y + left.h - 1, right.y + right.h - 1);
                        int y = rnd.GetRandomInt(miny, maxy);
                        hline_left(bsp_map, right.x - 1, y);
                        hline_right(bsp_map, right.x, y);
                    }
                }
            }
            return true;
        }
        #endregion

        



        public char[,] GenerateLevel()
        {
            
            TCODBSP bsp = null;
            bool generate = true;
            bool refresh = false;

            int x, y;

            if (generate || refresh)
            {
                // dungeon generation
                if (bsp == null)
                {
                    // create the bsp
                    bsp = new TCODBSP(0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT);
                }
                else
                {
                    // restore the nodes size
                    bsp.Resize(0, 0, SAMPLE_SCREEN_WIDTH, SAMPLE_SCREEN_HEIGHT);
                }


                for (int x1 = 0; x1 < SAMPLE_SCREEN_WIDTH; x1++)
                    for (int y1 = 0; y1 < SAMPLE_SCREEN_HEIGHT; y1++)
                        bsp_map[x1, y1] = '#';


                if (generate)
                {
                    // build a new random bsp tree
                    bsp.RemoveSons();
                    bsp.SplitRecursive(null, bspDepth, minRoomSize + (roomWalls ? 1 : 0), minRoomSize + (roomWalls ? 1 : 0), 1.5f, 1.5f);
                }
                // create the dungeon from the bsp
                bsp.TraverseInvertedOrder(new TCODBSPTraversalDelegate(traverse_node));
                generate = false;
                refresh = false;
            }

            return bsp_map;



        }

    }
}
